package Composite;

import fichiers.*;
import Visitables.*;
import java.awt.Image;
import java.awt.image.*;
import java.io.*;
import java.util.*;
import javax.imageio.*;
import javax.swing.*;
import support.*;


public class Dossier extends Element {
// public class Dossier extends Element implements Runnable{
    private boolean verification;
    private ArrayList elements;
    private static BufferedImage vignette;
    
    public Dossier(Element pere, File courant, String nom) {
        super(pere, courant, nom);

            this.elements = new ArrayList();
            this.setType("Dossier");
            if (this.getPere() == null) {
                this.verification = false;
            } else {
                this.verification = ((Dossier) this.getPere()).getVerification();
            }
       
    }
    
        public Image getVignette() {
        
          if(vignette!=null) return vignette;
          try {
            vignette = ImageIO.read(new File("dossier100.png"));
         } catch (IOException ex) {
            System.out.println("Erreur de lecteur vignette de dossier");
        }          
            return vignette;
        }

    public boolean allowsChildren() {
        return true;
    }
    
    public boolean estUnePhoto(){
        
        return false;
    }
    
        public Element getSousElement(String nomDossier){
            
            Iterator it = this.elements.iterator();
            while(it .hasNext()){

                Element suiv = (Element) it.next();
                if(suiv.toString().equals(nomDossier)) return suiv;
            }
            
            return null;
        }
        
        public int getChildCount() {
        
        return this.elements.size();
    }
    
    public boolean addChild(Element e) {

        boolean b= this.elements.add(e);
        this.setChanged();
        this.notifyObservers(e);
        return b;
    }
    
    public boolean removeChild(Element e) {

        boolean b=this.elements.remove(e);
        e.setPere(null);
        this.setChanged();
        this.notifyObservers(e);
        return b;
    }
    
            public void removeChilds() {
    
                Iterator it=(new ArrayList(this.elements)).iterator();
                while(it.hasNext()){
                    
                    Element suiv=(Element)it.next();
                    this.removeChild(suiv);
                }
                
            }
            
            
    public Element getChild(int index) {
        
        return (Element) this.elements.get(index);
    }
   
    
    public boolean addChild(Element e, int index) {

        this.elements.add(index, e);
        this.setChanged();
        this.notifyObservers(e);
        return true;
    }
    
    public void accept(Visiteur v) {
        
        v.visiteDossier(this);
        ArrayList temp = new ArrayList(this.elements);
        Iterator<Element> it = temp.iterator();
        while (it.hasNext()){
            
            Element suiv = it.next();
            suiv.accept(v);
        }
    }
    
        public boolean estUnNomValide(String nom){
        
        Iterator it=this.elements.iterator();
        while(it.hasNext()){          
            Element suiv=(Element)it.next();
            if(suiv.toString().equals(nom)) return false;
        }
        
        return true;
    }
        
    protected Element recupererFichierRecursive(String path,Element retour){
        
        if(this.getFichierCourant()!=null && path.equals(this.getFichierCourant().getPath())){
            
            retour=this;
            
        }else{
            
            Iterator i=this.elements.iterator();
            while(i.hasNext()){
                
                Element suiv=(Element) i.next();
                retour=suiv.recupererFichierRecursive(path, retour);
                
                
            }
        }        return retour;
    }
    
    
    public Dossier getCopie(Dossier parent) {
        
        Dossier nouveau = new Dossier(parent, new File(this.getFichierCourant().getAbsolutePath()), new String(this.toString()));
        nouveau.verification = this.verification ;
               
        return nouveau;
    }
            
    public boolean getVerification() {
        
        return this.verification;
    }
    
     public ArrayList getDossiers() {
        
        return this.elements;
    }
    public void setVerification(boolean verif) {
        
        this.setVerificationRecursif(verif);
        ThreadVerification threadV = new ThreadVerification(this);
        threadV.start();
        
    }
        public void setVerificationSimple(boolean verif) {
        
        this.verification=verification;
        
    }
    
    public void setVerificationRecursif(boolean verif) {
        
        this.verification = verif;
        this.setChanged();
        this.notifyObservers(this);
        
        if (this.elements.size() != 0) {
            
            Iterator<Element> i = this.elements.iterator();
            while (i.hasNext()) {
                
                Element temp = i.next();
                ((Dossier) temp).setVerificationRecursif(verification);
            }
            
        }
    }
    

    public int getIndex(Element e) {
        
        int index = 0;
        Iterator it = this.elements.iterator();
        while (it.hasNext()) {
            
            Element suiv = (Element) it.next();
            if ((suiv.toString()).compareToIgnoreCase(e.toString()) < 0) index++;
            

         }
        return index;
    }
    
    
    public boolean contientFichier(File f) {
        
        ArrayList temp = new ArrayList(this.elements);
        Iterator<Element> it = temp.iterator();
        while (it.hasNext()) {
            
            Element suiv = it.next();
            if (suiv.getFichierCourant().getName().equals(f.getName())) {
                
                return true;
            }
        }
        return false;
    }
    

    public void charger(){
        
        Iterator it = this.getDossiers().iterator();
        while(it.hasNext()){
            
            Element suiv=(Element)it.next();
            this.setChanged();
            this.notifyObservers(suiv);
            if(suiv instanceof Dossier){
                
                ((Dossier)suiv).charger();
            }
        }
    }


    public ImageIcon getRepresentation() {

        return this.dossier;
    }

     
    
}
class ThreadVerification extends Thread {
    
    private Dossier d;
    
    public ThreadVerification(Dossier d) {
        
        this.d = d;
        
    }
    
    public void run() {
        RacineDossier.getRacine().getGestionnaire().mettreAJour(d);
    }
}


